home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / MacPerl ƒ / Perl Source ƒ / MacPerl / MPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-15  |  16.1 KB  |  764 lines  |  [TEXT/MPS ]
  1. /*********************************************************************
  2. Project    :    MacPerl            -    Real Perl Application
  3. File        :    MPFile.c            -
  4. Author    :    Matthias Neeracher
  5.  
  6. A lot of this code is borrowed from 7Edit written by
  7. Apple Developer Support UK
  8.  
  9. Started    :    17Mar93                                Language    :    MPW C
  10. Modified    :    29May93    MN    Compiles correctly
  11.                 30May93    MN    Support Console Windows
  12.                 13Aug93    MN    Write bounds rectangles
  13.                 17Aug93    MN    Enable Save
  14.                 28Aug93    MN    Handle multiple preference files
  15.                 17Sep93    MN    Runtime version
  16. Last        :    17Sep93
  17. *********************************************************************/
  18.  
  19. #include <Errors.h>
  20. #include <Resources.h>
  21. #include <Desk.h>
  22. #include <PLStringFuncs.h>
  23. #include <AppleEvents.h>
  24. #include <AERegistry.h>
  25. #include <StandardFile.h>
  26. #include <TFileSpec.h>
  27.  
  28. #include "MPFile.h"
  29. #include "MPSave.h"
  30.  
  31. /**-----------------------------------------------------------------------
  32.         Name:             FileError
  33.         Purpose:        Puts up an error alert.
  34.     -----------------------------------------------------------------------**/
  35.  
  36.  
  37. #pragma segment File
  38.  
  39. pascal void FileError(Str255 s, Str255 f)
  40. {
  41.     short    alertResult;
  42.  
  43.     SetCursor(&qd.arrow);
  44.     ParamText(s, f, "", "");
  45.      alertResult = Alert(ErrorAlert, nil);
  46. }
  47.  
  48. /**-----------------------------------------------------------------------
  49.         Name:             DoClose
  50.         Purpose:        Closes a window.
  51.     -----------------------------------------------------------------------**/
  52.  
  53. #pragma segment File
  54.  
  55. pascal OSErr DoClose(WindowPtr aWindow, Boolean canInteract, DescType dialogAnswer)
  56. {
  57.      DPtr    aDocument;
  58.      short   alertResult;
  59.      Str255  theName;
  60.     OSErr   myErr;
  61.  
  62.     myErr = noErr;
  63.  
  64.      if (gWCount > 0) {
  65.         aDocument = DPtrFromWindowPtr(aWindow);
  66.  
  67.         if (aDocument->kind == kDocumentWindow) {
  68.             if (aDocument->dirty)
  69.                 if (canInteract && (dialogAnswer==kAEAsk)) {
  70.                     if (aDocument->u.reg.everSaved == false)
  71.                         GetWTitle(aWindow, theName); /* Pick it up as a script may have changed it */
  72.                     else
  73.                         PLstrcpy(theName, aDocument->theFileName);
  74.     
  75.                     ParamText(theName, "", "", "");
  76.                     SetCursor(&qd.arrow);
  77.                     alertResult = Alert(SaveAlert, nil);
  78.                     switch (alertResult) {
  79.                     case aaSave:
  80.                         myErr = SaveAskingName(aDocument, canInteract);
  81.                         break;
  82.     
  83.                     case aaCancel:
  84.                         return userCanceledErr;
  85.     
  86.                     case aaDiscard:
  87.                         aDocument->dirty = false;
  88.                         break;
  89.                     }
  90.                 } else {
  91.                     if (dialogAnswer==kAEYes)
  92.                         myErr = SaveAskingName(aDocument, canInteract);
  93.                     else
  94.                         myErr = noErr; /* Don't save */
  95.                 }
  96.                 
  97.             if (!myErr) {
  98. #ifndef RUNTIME
  99.                 if (aDocument->kind == kDocumentWindow && aDocument->u.reg.numSections)
  100.                     DeRegisterAllSections(aDocument);
  101. #endif
  102.  
  103.                 CloseMyWindow(aWindow);
  104.             }
  105.         } else if (aDocument->u.cons.selected) {
  106.             if (!gQuitting) {
  107.                 SysBeep(0);
  108.     
  109.                 return userCanceledErr;
  110.             }
  111.         } else 
  112.             SaveConsole(aDocument);
  113.     } else
  114.         myErr = errAEIllegalIndex;
  115.  
  116.     return myErr;
  117. }
  118.  
  119. #pragma segment File
  120.  
  121. //  DoQuit
  122. //  saveOpt - one of kAEAsk,kAEYes,kAENo
  123. //  if kAEYes or kAEAsk then AEInteactWithUser should have been called
  124. //  before DoQuit. Assumes that it can interact if it needs to.
  125.  
  126. pascal void DoQuit(DescType saveOpt)
  127. {
  128.     WindowPeek    aWindow;
  129.     WindowPeek    nextWindow;
  130.     short            theKind;
  131.  
  132.     if (gRunningPerl && (Alert(AbortAlert, nil) == 2))
  133.         return;
  134.         
  135.     gQuitting = true;
  136.  
  137.     for (aWindow = (WindowPeek) FrontWindow(); aWindow; aWindow = nextWindow) {
  138.         nextWindow = aWindow->nextWindow;
  139.         if (Ours((WindowPtr) aWindow)) {
  140.             if (DoClose((WindowPtr) aWindow, true, saveOpt)) {
  141.                 gQuitting = false;
  142.                 
  143.                 return;
  144.             }
  145.         } else {
  146.             theKind = aWindow->windowKind;
  147.             if (theKind < 0)
  148.                 CloseDeskAcc(theKind);
  149.         }
  150.     }
  151. }
  152.  
  153. pascal Boolean GetFileFilter(ParmBlkPtr info)
  154. {
  155.     switch (info->fileParam.ioFlFndrInfo.fdType) {
  156.     case 'APPL':
  157.         switch (info->fileParam.ioFlFndrInfo.fdCreator) {
  158.         case MPRtSig:
  159.             return false;
  160.         case MPAppSig:
  161.             return !info->fileParam.ioFlLgLen;
  162.         default:
  163.             return true;
  164.         }
  165.     case 'TEXT':
  166.         return false;
  167.     default:
  168.         return true;
  169.     }
  170. }
  171.  
  172. pascal OSErr GetFile(FSSpec *theFSSpec)
  173. {
  174. #ifndef RUNTIME
  175.  
  176.     SFTypeList         myTypes = {'TEXT', 'APPL'};
  177.     StandardFileReply  reply;
  178.  
  179.     StandardGetFile(GetFileFilter, 2, myTypes, &reply);
  180.  
  181.     if (reply.sfGood) {
  182.         *theFSSpec = reply.sfFile;
  183.         return noErr;
  184.     } else
  185.         return userCanceledErr;
  186.         
  187. #else
  188.  
  189.     SFTypeList     myTypes = {'TEXT', 'APPL'};
  190.     SFReply          reply;
  191.     Point            where;
  192.  
  193.     where.h = where.v = 75;
  194.  
  195.     SFGetFile(
  196.         where, "\p", 
  197.         GetFileFilter, 2, myTypes, 
  198.         (DlgHookProcPtr) nil,
  199.         &reply);
  200.  
  201.     if (reply.good)
  202.         return WD2FSSpec(reply.vRefNum, reply.fName, theFSSpec);
  203.     else
  204.         return userCanceledErr;
  205.         
  206. #endif
  207. }
  208.  
  209. #pragma segment File
  210.  
  211. pascal OSErr DoCreate(FSSpec theSpec)
  212. {
  213.     OSErr err;
  214.  
  215. #ifndef RUNTIME
  216.     err = FSpCreate(&theSpec, MPAppSig, 'TEXT', smSystemScript);
  217. #else
  218.     err = HCreate(theSpec.vRefNum, theSpec.parID, theSpec.name, MPAppSig, 'TEXT');
  219. #endif
  220.  
  221.     if (!err)
  222.         HCreateResFile(theSpec.vRefNum, theSpec.parID, theSpec.name);
  223.     else
  224.         ShowError("\pCreating", err);
  225.  
  226.     return err;
  227. }
  228.  
  229. pascal OSErr SaveConsole(DPtr doc)
  230. {
  231.     OSErr            err;
  232.     short       resFile;
  233.     HHandle     theHHandle;
  234.     Str255        title;
  235.     Boolean        existing;
  236.     
  237.     if (gPrefsFile) {
  238.         resFile    =    CurResFile();
  239.         UseResFile(gPrefsFile);
  240.         GetWTitle(doc->theWindow, title);
  241.         
  242.         if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  243.             existing = true;
  244.         } else {
  245.             existing = false;
  246.             theHHandle = (HHandle)NewHandle(sizeof(HeaderRec));
  247.         }
  248.         
  249.         HLock((Handle)theHHandle);
  250.     
  251.         (*theHHandle)->theRect     = doc->theWindow->portRect;
  252.         OffsetRect(
  253.             &(*theHHandle)->theRect,
  254.             -doc->theWindow->portBits.bounds.left,
  255.             -doc->theWindow->portBits.bounds.top);
  256.             
  257.         GetFontName((*(doc->theText))->txFont, &(*theHHandle)->theFont);
  258.         
  259.         (*theHHandle)->theSize     = (*(doc->theText))->txSize;
  260.         (*theHHandle)->lastID      = 0;
  261.         (*theHHandle)->numSections = 0;
  262.     
  263.         HUnlock((Handle)theHHandle);
  264.     
  265.         if (existing) {
  266.             ChangedResource((Handle) theHHandle);
  267.             WriteResource((Handle) theHHandle);
  268.             UpdateResFile(gPrefsFile);
  269.         } else {
  270.             AddResource((Handle)theHHandle, 'TFSS', Unique1ID('TFSS'), title);
  271.         }
  272.         
  273.         err = ResError();
  274.         
  275.         UseResFile(resFile);
  276.     }
  277.     
  278.     DoHideWindow(doc->theWindow);
  279.     TESetSelect(0, 32767, doc->theText);
  280.     TEDelete(doc->theText);
  281.     
  282.     if (doc->u.cons.fence < 32767)
  283.         doc->u.cons.fence    = 0;
  284.     
  285.     return err;
  286. } 
  287.  
  288. pascal void ApplySettings(DPtr doc, HPtr settings)
  289. {
  290.     short        fNum;
  291.     FontInfo    info;
  292.     Rect        bounds;
  293.     
  294.     GetFNum(settings->theFont, &fNum);
  295.     SetPort(doc->theWindow);
  296.     TextFont(fNum);
  297.     TextSize(settings->theSize);
  298.     GetFontInfo(&info);
  299.     
  300.     (*doc->theText)->txFont         = fNum;
  301.     (*doc->theText)->txSize         = settings->theSize;
  302.     (*doc->theText)->lineHeight    = info.ascent+info.descent+info.leading;
  303.     (*doc->theText)->fontAscent    = info.ascent;
  304.     
  305.     bounds                                = settings->theRect;
  306.     InsetRect(&bounds, 20, 20);
  307.     
  308.     if (settings->theRect.right > settings->theRect.left + 50 &&
  309.         settings->theRect.bottom > settings->theRect.top  + 50 &&
  310.         RectInRgn(&bounds, GetGrayRgn())
  311.     ) {
  312.         MoveWindow(doc->theWindow, settings->theRect.left, settings->theRect.top, false);
  313.         SizeWindow(
  314.             doc->theWindow,
  315.             settings->theRect.right - settings->theRect.left,
  316.             settings->theRect.bottom - settings->theRect.top,
  317.             false);
  318.     }
  319.         
  320.     ResizeWindow(doc);
  321. }
  322.  
  323. pascal void RestoreConsole(DPtr doc)
  324. {
  325.     short       resFile;
  326.     HHandle     theHHandle;
  327.     Str255        title;
  328.     
  329.     if (!gPrefsFile)
  330.         return;
  331.         
  332.     resFile    =    CurResFile();
  333.     UseResFile(gPrefsFile);
  334.     GetWTitle(doc->theWindow, title);
  335.     
  336.     if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  337.          HLock((Handle)theHHandle);
  338.         
  339.         ApplySettings(doc, *theHHandle);
  340.         
  341.         HUnlock((Handle)theHHandle);
  342.     }
  343.     
  344.     UseResFile(resFile);
  345. }
  346.  
  347.  
  348. /** -----------------------------------------------------------------------
  349.         Name:         GetFileContents
  350.         Purpose:        Opens the document specified by theFSSpec and puts
  351.                         the contents into theDocument.
  352.      -----------------------------------------------------------------------**/
  353.  
  354. #pragma segment File
  355.  
  356. pascal OSErr GetFileContents(FSSpec spec, DPtr theDocument)
  357. {
  358.     long            theSize;
  359.     short            oldRes;
  360.     short            resFile;
  361.     short            refNum;
  362.     OSErr            err;
  363.     HHandle        aHandle;
  364.     Handle        gHandle;
  365.  
  366.     oldRes    =    CurResFile();
  367.     resFile     =    HOpenResFile(spec.vRefNum, spec.parID, spec.name, fsRdPerm);
  368.  
  369.     switch (theDocument->type) {
  370.     case kOldRuntime6Doc:
  371.     case kPlainTextDoc:
  372. #ifndef RUNTIME
  373.         if (err = HOpenDF(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  374.             ShowError("\pread file - HOpenDF", err);
  375. #else
  376.         if (err = HOpen(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  377.             ShowError("\pread file - HOpen", err);
  378. #endif
  379.             refNum = 0;
  380.             
  381.             goto giveUp;
  382.         }
  383.     
  384.         if (err = GetEOF(refNum, &theSize))
  385.             goto giveUp;
  386.  
  387.           gHandle = NewHandle(theSize);
  388.  
  389.         HLock(gHandle);
  390.         if (err = FSRead(refNum, &theSize, *gHandle))
  391.             return err;
  392.         HUnlock(gHandle);
  393.         FSClose(refNum);
  394.         break;
  395.         
  396. giveUp:    
  397.         if (refNum)
  398.             FSClose(refNum);
  399.             
  400.         if (resFile > -1)
  401.             CloseResFile(resFile);
  402.         
  403.         UseResFile(oldRes);
  404.         
  405.         return err;
  406.     default:
  407.         gHandle    =    Get1NamedResource('TEXT', "\p!");
  408.         
  409.         if (gHandle) 
  410.             DetachResource(gHandle);
  411.         else {
  412.             err = ResError();
  413.             
  414.             goto giveUp;
  415.         }
  416.         break;
  417.     }
  418.  
  419.     theDocument->u.reg.numSections = 0;
  420.  
  421.     if (resFile != -1) {
  422.         aHandle = nil;
  423.  
  424.         if (Count1Resources('TFSS'))
  425.             aHandle = (HHandle)Get1Resource('TFSS', 255);
  426.  
  427.         if (aHandle) {
  428.             theDocument->u.reg.numSections = (*aHandle)->numSections;
  429.             
  430.             HLock((Handle) aHandle);
  431.             ApplySettings(theDocument, *aHandle);
  432.         }
  433.  
  434.         /*
  435.             If there is a print record saved, ditch the old one
  436.             created by new document and fill this one in
  437.         */
  438.         if (Count1Resources('TFSP')) {
  439.             if (theDocument->thePrintSetup)
  440.                 DisposHandle((Handle)theDocument->thePrintSetup);
  441.  
  442.             theDocument->thePrintSetup = (THPrint)Get1Resource('TFSP', 255);
  443.               HandToHand((Handle *)&theDocument->thePrintSetup);
  444.  
  445.             PrValidate(theDocument->thePrintSetup);
  446.         }
  447.  
  448. #ifndef RUNTIME
  449.         if (theDocument->u.reg.numSections) {
  450.             ReadSectionRecords(theDocument);
  451.             ReadAllSectionResources(theDocument);
  452.         }
  453. #else
  454.         theDocument->u.reg.numSections    =    0;
  455. #endif
  456.  
  457.         CloseResFile(resFile);
  458.  
  459.         if (err = ResError()) {
  460.             ShowError("\pread file- CloseResFile", err);
  461.             return err;
  462.         }
  463.     }
  464.  
  465.     HLock(gHandle);
  466.     if (GetHandleSize(gHandle) > 32000) {
  467.         PtrToXHand(
  468.             *gHandle, 
  469.             (*theDocument->theText)->hText, 
  470.             GetHandleSize(gHandle));
  471.         
  472.         err = elvisErr;
  473.     } else
  474.         TESetText(*gHandle, GetHandleSize(gHandle), theDocument->theText);
  475.     DisposHandle(gHandle);
  476.  
  477.     if (err == fnfErr)
  478.         return noErr;
  479.     else
  480.           return err;
  481. } /* GetFileContents */
  482.  
  483.  
  484. #pragma segment File
  485.  
  486. pascal OSErr SaveAskingName(DPtr aDocument, Boolean canInteract)
  487. {
  488.     OSErr    myErr;
  489.  
  490.     if (aDocument->kind != kDocumentWindow || !aDocument->u.reg.everSaved) {
  491.  
  492.         if (canInteract) {
  493.             if (myErr = GetFileNameToSaveAs(aDocument))
  494.                 return myErr;
  495.  
  496.             if (myErr = DoSave(aDocument, aDocument->theFSSpec))
  497.                 return myErr;
  498.  
  499. #ifndef RUNTIME
  500.             AssocAllSections(aDocument);
  501. #endif
  502.  
  503.             return noErr;
  504.         } else
  505.             return errAENoUserInteraction;
  506.  
  507.     } else
  508.         return SaveUsingTemp(aDocument);
  509. }
  510.  
  511. #pragma segment File
  512.  
  513. pascal OSErr SaveUsingTemp(DPtr theDocument)
  514. {
  515.     Str255    tempName;
  516.     OSErr        err;
  517.     FSSpec    tempFSSpec;
  518.  
  519.     /*save the file to disk using a temporary file*/
  520.     /*this is the recommended way of doing things*/
  521.     /*first write out the file to disk using a temporary filename*/
  522.     /*if it is sucessfully written, exchange the temporary file with the last one saved*/
  523.     /*then delete the temporary file- so if anything goes wrong, the original version is still there*/
  524.     /*first generate the temporary filename*/
  525.  
  526.     GetTempFileName(theDocument, &tempName);
  527.     /*create this file on disk*/
  528.  
  529.     tempFSSpec = theDocument->theFSSpec;
  530.     PLstrcpy(tempFSSpec.name, tempName);
  531.  
  532.     if (err = DoCreate(tempFSSpec))
  533.         return err;
  534.  
  535.     if (err = DoSave(theDocument, tempFSSpec))
  536.         return err;
  537.     
  538. #ifndef RUNTIME
  539.     if (err = FSpExchangeFiles(&tempFSSpec, &theDocument->theFSSpec))
  540.         return err;
  541.  
  542.     /*we've exchanged the files, now delete the temporary one*/
  543.  
  544.     err = FSpDelete(&tempFSSpec);
  545. #else
  546.     err = FSpSmartMove(&tempFSSpec, &theDocument->theFSSpec);
  547. #endif
  548.     
  549.     if (!err)
  550.         theDocument->dirty = false;
  551.  
  552.     return err;
  553. }
  554.  
  555.  
  556. #pragma segment File
  557.  
  558. pascal short SaveScriptHook(short item, DialogPtr dlg, void * params)
  559. {
  560.     short                kind;
  561.     ControlHandle    type;
  562.     Rect                r;
  563.     DPtr                doc = (DPtr) params;
  564.     
  565.     if (GetWRefCon(dlg) != 'stdf')
  566.         return item;
  567.         
  568.     switch (item) {
  569.     case sfHookFirstCall:
  570.         GetDItem(dlg, ssd_Type, &kind, (Handle *) &type, &r);
  571.         SetCtlValue(type, doc->type);
  572.         
  573.         return sfHookFirstCall;
  574.     case ssd_Type:
  575.         GetDItem(dlg, item, &kind, (Handle *) &type, &r);
  576.         
  577.         doc->type = (DocType) GetCtlValue(type);
  578.         
  579.         return sfHookNullEvent;
  580.     default:
  581.         return item;
  582.     }
  583. }
  584.  
  585. /*
  586.     Fills in the document record with the user chosen destination
  587. */
  588.  
  589. pascal OSErr GetFileNameToSaveAs(DPtr theDocument)
  590. {
  591. #ifndef RUNTIME
  592.     OSErr                    err;
  593.     StandardFileReply    reply;
  594.     Str255            suggestName;
  595.     Point                    where;
  596.     
  597.     where.h = where.v = -1;
  598.  
  599.     GetWTitle(theDocument->theWindow, suggestName);
  600.  
  601.     CustomPutFile(
  602.         "\pSave Document As:", suggestName, &reply,
  603.         SaveScriptDialog,
  604.         where,
  605.         SaveScriptHook,
  606.         (ModalFilterYDProcPtr) nil,
  607.         nil,
  608.         (ActivateYDProcPtr) nil,
  609.         theDocument);
  610.  
  611.     if (reply.sfGood)
  612.         switch (err = FSpDelete(&reply.sfFile)) {
  613.         case noErr:
  614.         case fnfErr:
  615.             theDocument->theFSSpec = reply.sfFile;
  616.             PLstrcpy(theDocument->theFileName, reply.sfFile.name);
  617.  
  618.             return noErr;
  619.         default:
  620.             return err;
  621.         }
  622.     else
  623.         return userCanceledErr;
  624. #else
  625.     OSErr        err;
  626.     SFReply    reply;
  627.     Str255   suggestName;
  628.     Point        where;
  629.  
  630.     where.h = where.v = 75;
  631.     
  632.     GetWTitle(theDocument->theWindow, suggestName);
  633.  
  634.     SFPutFile(
  635.         where, "\pSave Document As:", 
  636.         suggestName, (DlgHookProcPtr) nil,
  637.         &reply);
  638.     
  639.     if (reply.good) {
  640.         FSSpec    spec;
  641.         
  642.         if (err = WD2FSSpec(reply.vRefNum, reply.fName, &spec))
  643.             return err;
  644.         switch (err = HDelete(spec.vRefNum, spec.parID, spec.name)) {
  645.         case noErr:
  646.         case fnfErr:
  647.             theDocument->theFSSpec = spec;
  648.             PLstrcpy(theDocument->theFileName, spec.name);
  649.  
  650.             return noErr;
  651.         default:
  652.             return err;
  653.         }
  654.     } else
  655.         return userCanceledErr;
  656. #endif
  657. } /* GetFileNameToSaveAs */
  658.  
  659. #pragma segment File
  660.  
  661. pascal OSErr OpenOld(FSSpec aFSSpec, DocType type)
  662. {
  663.     DPtr          theDocument;
  664.     OSErr         fileErr;
  665.     
  666.     theDocument = NewDocument(true, kDocumentWindow);
  667.  
  668.     SetWTitle(theDocument->theWindow, aFSSpec.name);
  669.  
  670.     SetPort(theDocument->theWindow);
  671.  
  672.     theDocument->theFSSpec   = aFSSpec;
  673.  
  674.     PLstrcpy(theDocument->theFileName,aFSSpec.name);
  675.  
  676.     theDocument->dirty               = false;
  677. #ifndef RUNTIME
  678.     theDocument->type                    = (type == kOldRuntime6Doc) ? kRuntime6Doc : type;
  679.     theDocument->u.reg.everSaved    = (type != kOldRuntime6Doc);
  680. #else
  681.     theDocument->type                    = kPlainTextDoc;
  682.     theDocument->u.reg.everSaved    = (type == kPlainTextDoc);
  683. #endif
  684.  
  685.     fileErr = GetFileContents(aFSSpec, theDocument);
  686.  
  687.     if (!fileErr) {
  688.         ResizeWindow(theDocument);
  689.         DoShowWindow(theDocument->theWindow);
  690.     } else {
  691.         if (fileErr == elvisErr) {
  692.             theDocument->u.reg.everSaved    = false;
  693. #ifdef RUNTIME
  694.             if (AEInteractWithUser(kAEDefaultTimeout, nil, nil))
  695. #endif
  696.                 if (Alert(ElvisAlert, nil) == 1)
  697.                     SaveAskingName(theDocument, true);
  698.         } else
  699.             FileError("\pError Opening ", aFSSpec.name);
  700.         
  701.         CloseMyWindow(theDocument->theWindow);
  702.     }
  703.  
  704.     return fileErr;
  705. } /* OpenOld */
  706.  
  707. pascal DocType GetDocType(FSSpec * spec)
  708. {
  709.     CInfoPBRec    info;
  710.     DocType        type    =    kUnknownDoc;
  711.     short            resFile;
  712.     short            nuFile;
  713.     OSType    **    rtType;
  714.  
  715.     if (FSpCatInfo(spec, &info))
  716.         return kUnknownDoc;
  717.     
  718.     switch (info.hFileInfo.ioFlFndrInfo.fdType) {
  719.     case 'APPL':
  720.         switch (info.hFileInfo.ioFlFndrInfo.fdCreator) {
  721.         case MPRtSig:
  722.             resFile    =    CurResFile();
  723.             nuFile    =    HOpenResFile(spec->vRefNum, spec->parID, spec->name, fsRdPerm);
  724.             
  725.             if (nuFile != -1) {
  726.                 if (rtType = (OSType **) Get1Resource('MrPL', 128))
  727.                     switch (**rtType) {
  728.                     case 'SCPT':
  729.                         type        =    kScriptDoc;
  730.                         break;
  731.                     case 'MrP7':
  732.                         type        =    kRuntime7Doc;
  733.                         break;
  734.                     case 'MrP6':
  735.                         type         =    kRuntime6Doc;
  736.                         break;
  737.                     }
  738.                     
  739.                 CloseResFile(nuFile);
  740.             }
  741.             UseResFile(resFile);
  742.             
  743.             return type;
  744.         case MPAppSig:
  745.             /* A heuristic to separate old runtimes from PowerPC executables */
  746.             if (info.hFileInfo.ioFlLgLen && info.hFileInfo.ioFlLgLen < 100000)
  747.                 return kOldRuntime6Doc; 
  748.             /* Fall through */
  749.         default:
  750.             return kUnknownDoc;
  751.         }
  752.     case 'TEXT':
  753.         return kPlainTextDoc;
  754.     case 'pref':
  755.         switch (info.hFileInfo.ioFlFndrInfo.fdCreator) {
  756.         case MPAppSig:
  757.         case MPRtSig:
  758.             return kPreferenceDoc;
  759.         }
  760.         /* Fall through */
  761.     default:
  762.         return kUnknownDoc;
  763.     }
  764. }